package com.lhkk.inventoryvehicle.camera;//package com.crrc.sandameter.camera;
//
//import android.Manifest;
//import android.content.Context;
//import android.content.pm.PackageManager;
//import android.graphics.ImageFormat;
//import android.graphics.SurfaceTexture; // 需要导入 SurfaceTexture
//import android.hardware.camera2.CameraAccessException;
//import android.hardware.camera2.CameraCaptureSession;
//import android.hardware.camera2.CameraCharacteristics;
//import android.hardware.camera2.CameraDevice;
//import android.hardware.camera2.CameraManager;
//import android.hardware.camera2.CaptureRequest;
//import android.hardware.camera2.TotalCaptureResult;
//import android.hardware.camera2.params.StreamConfigurationMap;
//import android.media.Image;
//import android.media.ImageReader;
//import android.os.Handler;
//import android.os.HandlerThread;
//import android.util.Log;
//import android.util.Size;
//import android.view.Surface;
//import android.view.SurfaceHolder;
//import android.view.SurfaceView;
//
//import androidx.annotation.NonNull;
//import androidx.core.content.ContextCompat;
//
//import java.nio.ByteBuffer;
//import java.util.ArrayList; // 需要导入 ArrayList
//import java.util.Arrays;
//import java.util.Collections;
//import java.util.Comparator;
//import java.util.List; // 需要导入 List
//import java.util.concurrent.Semaphore;
//import java.util.concurrent.TimeUnit;
//
//public class Camera2Helper {
//
//    private static final String TAG = "Camera2Helper";
//
//    // 相机设备对象
//    private CameraDevice mCameraDevice;
//    // 预览会话对象
//    private CameraCaptureSession mCaptureSession;
//    // 预览请求构建器
//    private CaptureRequest.Builder mPreviewRequestBuilder;
//    // 预览请求
//    private CaptureRequest mPreviewRequest;
//    // 用于接收静态图像的 ImageReader
//    private ImageReader mImageReader;
//    // 用于显示相机预览的 SurfaceView
//    private SurfaceView mSurfaceView;
//    // 后台线程，用于处理相机相关的任务
//    private HandlerThread mBackgroundThread;
//    // 后台线程的 Handler
//    private Handler mBackgroundHandler;
//    // 用于确保在关闭相机之前不会退出应用程序
//    private Semaphore mCameraOpenCloseLock = new Semaphore(1);
//    // 相机 ID，这里默认使用后置摄像头
//    private String mCameraId;
//    // 预览尺寸
//    private Size mPreviewSize;
//    // 拍照尺寸
//    private Size mImageSize;
//    // 应用上下文
//    private Context mContext;
//
//    // 相机设备状态回调
//    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
//
//        @Override
//        public void onOpened(@NonNull CameraDevice cameraDevice) {
//            // 相机成功打开时调用
//            mCameraOpenCloseLock.release();
//            mCameraDevice = cameraDevice;
//            new Handler(mContext.getMainLooper()).post(() -> {
//                String threadedName = Thread.currentThread().getName();
//                // 创建相机预览会话
//                createCameraPreviewSession();
//            });
//        }
//
//        @Override
//        public void onDisconnected(@NonNull CameraDevice cameraDevice) {
//            // 相机断开连接时调用
//            mCameraOpenCloseLock.release();
//            cameraDevice.close();
//            mCameraDevice = null;
//        }
//
//        @Override
//        public void onError(@NonNull CameraDevice cameraDevice, int error) {
//            // 相机打开出错时调用
//            mCameraOpenCloseLock.release();
//            cameraDevice.close();
//            mCameraDevice = null;
//            Log.e(TAG, "CameraDevice.StateCallback onError: " + error);
//        }
//    };
//
//    // 捕获会话状态回调
//    private final CameraCaptureSession.StateCallback mSessionStateCallback = new CameraCaptureSession.StateCallback() {
//        @Override
//        public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
//            // 会话配置完成时调用
//            mCaptureSession = cameraCaptureSession;
//            try {
//                // 设置自动对焦模式
//                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//                // 设置自动白平衡模式
//                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_AUTO);
//                // 设置自动曝光模式
//                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
//
//
//                // 构建预览请求
//                mPreviewRequest = mPreviewRequestBuilder.build();
//                // 设置重复捕获请求，开始预览
//                mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, mBackgroundHandler);
//            } catch (CameraAccessException e) {
//                Log.e(TAG, "Failed to set repeating request", e);
//            }
//        }
//
//        @Override
//        public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
//            // 会话配置失败时调用
//            Log.e(TAG, "CameraCaptureSession onConfigureFailed");
//        }
//    };
//
//    // 捕获回调，用于处理捕获结果
//    private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
//        // 可以根据需要在这里处理捕获结果，例如判断对焦状态等
//    };
//
//    // ImageReader 图像可用回调
//    private final ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() {
//        @Override
//        public void onImageAvailable(ImageReader reader) {
//            // 当有新的图像可用时调用
//            mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage()));
//        }
//    };
//
//    // 用于保存图像的 Runnable
//    private static class ImageSaver implements Runnable {
//        private final Image mImage;
//
//        ImageSaver(Image image) {
//            mImage = image;
//        }
//
//        @Override
//        public void run() {
//            if (mImage == null) {
//                Log.e(TAG, "ImageSaver received null image");
//                return;
//            }
//            ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
//            byte[] bytes = new byte[buffer.remaining()];
//            buffer.get(bytes);
//            // TODO: 在这里实现图像的保存逻辑，例如保存到文件
//            Log.d(TAG, "Captured image data size: " + bytes.length);
//            // 例如：保存到文件
//            // File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "pic_" + System.currentTimeMillis() + ".jpg");
//            // try (FileOutputStream output = new FileOutputStream(file)) {
//            //     output.write(bytes);
//            //     Log.d(TAG, "Saved: " + file.getAbsolutePath());
//            // } catch (IOException e) {
//            //     Log.e(TAG, "Error saving image", e);
//            // } finally {
//            mImage.close(); // 确保图像被关闭
//            // }
//            mImage.close(); // 确保图像被关闭
//        }
//    }
//
//    public Camera2Helper(Context context, SurfaceView surfaceView) {
//        mContext = context;
//        mSurfaceView = surfaceView;
//        // 确保 SurfaceView 已经创建并持有 Surface
//        mSurfaceView.getHolder().addCallback(new SurfaceHolder.Callback() {
//            @Override
//            public void surfaceCreated(@NonNull SurfaceHolder holder) {
//                // Surface 创建时打开相机
//                Log.d(TAG, "Surface created. Opening camera.");
//                openCamera(mSurfaceView.getWidth(), mSurfaceView.getHeight());
//            }
//
//            @Override
//            public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
//                Log.d(TAG, "Surface changed. Width: " + width + ", Height: " + height);
//                // Surface 尺寸改变时可以重新配置相机或预览
//                // 如果需要，可以在这里调用 createCameraPreviewSession() 重新创建会话
//            }
//
//            @Override
//            public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
//                // Surface 销毁时关闭相机
//                Log.d(TAG, "Surface destroyed. Closing camera.");
//                closeCamera();
//            }
//        });
//    }
//
//    /**
//     * 打开指定尺寸的相机。
//     * 需要 CAMERA 权限。
//     */
//    public void openCamera(int width, int height) {
//
//        // 启动后台线程
//        startBackgroundThread();
//
//        CameraManager manager = (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
//        try {
//            // 尝试获取相机打开锁，超时 2500ms
//            if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
//                throw new RuntimeException("Time out waiting to lock camera opening.");
//            }
//
//            // 遍历所有相机，找到后置摄像头并获取其特性
//            for (String cameraId : manager.getCameraIdList()) {
//                CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
//
//                // 不使用前置摄像头
//                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
//                if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
//                    continue;
//                }
//
//                // 获取 StreamConfigurationMap，其中包含相机支持的输出尺寸
//                StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
//                if (map == null) {
//                    continue;
//                }
//
//                // 选择最大的可用 JPEG 尺寸作为拍照尺寸
//                mImageSize = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
//                Log.d(TAG, "Selected image size: " + mImageSize.getWidth() + "x" + mImageSize.getHeight());
//
//                // 创建 ImageReader 来处理拍照数据
//                mImageReader = ImageReader.newInstance(mImageSize.getWidth(), mImageSize.getHeight(), ImageFormat.JPEG, /*maxImages*/2);
//                mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, mBackgroundHandler);
//
//                // 选择适合预览的尺寸
//                // 这里简单选择一个与 SurfaceView 尺寸接近的尺寸，实际应用中需要更复杂的逻辑
//                // getOutputSizes(SurfaceTexture.class) 用于获取可用于 TextureView 的尺寸
//                // 如果使用 SurfaceView，可能需要调整
//                Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class); // 或者 map.getOutputSizes(SurfaceHolder.class)? 需要根据 SurfaceView 实际支持类型确定
//                if (outputSizes == null) {
//                    Log.e(TAG, "No output sizes available for SurfaceTexture or similar.");
//                    continue;
//                }
//
//                mPreviewSize = chooseOptimalSize(outputSizes, width, height, mImageSize); // Note: Need to verify correct output class for SurfaceView
//                Log.d(TAG, "Selected preview size: " + mPreviewSize.getWidth() + "x" + mPreviewSize.getHeight());
//
//
//                mCameraId = cameraId;
//                Log.d(TAG, "Found back facing camera with ID: " + mCameraId);
//                break; // 找到后置摄像头后退出循环
//            }
//
//            // 如果没有找到后置摄像头
//            if (mCameraId == null) {
//                Log.e(TAG, "Failed to find a back facing camera");
//                mCameraOpenCloseLock.release(); // 确保在出错时释放锁
//                return;
//            }
//
//
//        } catch (CameraAccessException e) {
//            Log.e(TAG, "CameraAccessException in openCamera", e);
//            mCameraOpenCloseLock.release(); // 确保在出错时释放锁
//            return;
//        } catch (InterruptedException e) {
//            throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
//        } catch (NullPointerException e) {
//            // 当设备支持 Camera2 API 但不支持特定硬件级别时可能发生
//            Log.e(TAG, "Camera2 API not fully supported on this device.", e);
//            mCameraOpenCloseLock.release(); // 确保在出错时释放锁
//            return;
//        }
//
//        // 如果找到相机并获取了 ID，则打开相机设备
//        try {
//            // 打开相机设备
//            manager.openCamera(mCameraId, mStateCallback, mBackgroundHandler);
//        } catch (CameraAccessException e) {
//            Log.e(TAG, "Failed to open camera", e);
//            mCameraOpenCloseLock.release(); // 确保在出错时释放锁
//        }
//    }
//
//    /**
//     * 关闭相机。
//     */
//    public void closeCamera() {
//        try {
//            // 尝试获取相机打开锁，超时 2500ms
//            mCameraOpenCloseLock.acquire();
//            if (null != mCaptureSession) {
//                mCaptureSession.close();
//                mCaptureSession = null;
//            }
//            if (null != mCameraDevice) {
//                mCameraDevice.close();
//                mCameraDevice = null;
//            }
//            if (null != mImageReader) {
//                mImageReader.close();
//                mImageReader = null;
//            }
//            Log.d(TAG, "Camera, session, and image reader closed.");
//        } catch (InterruptedException e) {
//            throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
//        } finally {
//            mCameraOpenCloseLock.release();
//        }
//        // 停止后台线程
//        stopBackgroundThread();
//    }
//
//    /**
//     * 创建相机预览会话。
//     */
//    private void createCameraPreviewSession() {
//        try {
//            Surface previewSurface = mSurfaceView.getHolder().getSurface();
//
//            // 创建预览请求构建器
//            mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
//            // 将 SurfaceView 的 Surface 添加到预览请求的输出
//            mPreviewRequestBuilder.addTarget(previewSurface);
//
//            // 创建相机捕获会话
//            mCameraDevice.createCaptureSession(Arrays.asList(previewSurface, mImageReader.getSurface()), mSessionStateCallback, mBackgroundHandler);
//            Log.d(TAG, "Creating camera preview session.");
//
//        } catch (CameraAccessException e) {
//            Log.e(TAG, "Failed to create camera preview session", e);
//        }
//    }
//
//    /**
//     * 拍照。
//     */
//    public void takePicture() {
//        if (null == mCameraDevice || null == mCaptureSession) {
//            Log.e(TAG, "Cannot take picture. Camera or session is null.");
//            return;
//        }
//
//        try {
//            // 创建拍照请求构建器
//            final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
//            // 将 ImageReader 的 Surface 添加到拍照请求的输出
//            captureBuilder.addTarget(mImageReader.getSurface());
//
//            // 设置拍照时的相机参数 (可以根据需要进行调整)
//            // 例如，可以使用与预览相同的自动对焦、白平衡、曝光模式
//            captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//            captureBuilder.set(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_AUTO);
//            captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
//
//            // 设置旋转角度，确保照片方向正确
//            // int rotation = ((Activity) mContext).getWindowManager().getDefaultDisplay().getRotation();
//            // captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation));
//
//            // 停止重复的预览请求，准备拍照
//            mCaptureSession.stopRepeating();
//            // 提交单次拍照请求
//            mCaptureSession.capture(captureBuilder.build(), new CameraCaptureSession.CaptureCallback() {
//                @Override
//                public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
//                    super.onCaptureCompleted(session, request, result);
//                    Log.d(TAG, "Picture capture completed.");
//                    // 拍照完成后，可以恢复预览
//                    createCameraPreviewSession();
//                }
//            }, mBackgroundHandler);
//            Log.d(TAG, "Sent picture capture request.");
//
//        } catch (CameraAccessException e) {
//            Log.e(TAG, "Failed to take picture", e);
//        }
//    }
//
//    /**
//     * 启动后台线程。
//     */
//    private void startBackgroundThread() {
//        if (mBackgroundThread == null || !mBackgroundThread.isAlive()) {
//            Log.d(TAG, "Starting background thread.");
//            mBackgroundThread = new HandlerThread("CameraBackground");
//            mBackgroundThread.start();
//            mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
//        }
//    }
//
//    /**
//     * 停止后台线程。
//     */
//    private void stopBackgroundThread() {
//        if (mBackgroundThread != null) {
//            Log.d(TAG, "Stopping background thread.");
//            mBackgroundThread.quitSafely();
//            try {
//                mBackgroundThread.join();
//                mBackgroundThread = null;
//                mBackgroundHandler = null;
//            } catch (InterruptedException e) {
//                Log.e(TAG, "Interrupted while stopping background thread", e);
//            }
//        }
//    }
//
//    /**
//     * 选择最佳的预览尺寸。
//     * 尝试找到一个与目标宽高比匹配且不大于容器尺寸的尺寸。
//     */
//    private Size chooseOptimalSize(Size[] choices, int surfaceWidth, int surfaceHeight, Size aspectRatio) {
//        // 收集支持的、至少与预览 Surface 同样大的尺寸
//        List<Size> bigEnough = new ArrayList<>();
//        // 收集支持的、比预览 Surface 小的尺寸
//        List<Size> notBigEnough = new ArrayList<>();
//        int w = aspectRatio.getWidth();
//        int h = aspectRatio.getHeight();
//        for (Size option : choices) {
//            if (option.getWidth() <= surfaceWidth && option.getHeight() <= surfaceHeight && option.getHeight() == option.getWidth() * h / w) {
//                if (option.getWidth() >= surfaceWidth && option.getHeight() >= surfaceHeight) {
//                    bigEnough.add(option);
//                } else {
//                    notBigEnough.add(option);
//                }
//            }
//        }
//
//        // 如果找到足够大的尺寸，选择其中最小的一个
//        if (bigEnough.size() > 0) {
//            return Collections.min(bigEnough, new CompareSizesByArea());
//        } else if (notBigEnough.size() > 0) {
//            // 如果没有足够大的尺寸，选择比 Surface 小但最大的那个
//            return Collections.max(notBigEnough, new CompareSizesByArea());
//        } else {
//            Log.e(TAG, "Couldn't find any suitable preview size");
//            // 如果没有找到合适的尺寸，返回支持的尺寸中最大的一个
//            return Collections.max(Arrays.asList(choices), new CompareSizesByArea());
//        }
//    }
//
//    /**
//     * 比较两个 Size 的面积。
//     */
//    static class CompareSizesByArea implements Comparator<Size> {
//        @Override
//        public int compare(Size lhs, Size rhs) {
//            // 比较它们的面积
//            return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
//        }
//    }
//
//    // TODO: 实现 getOrientation 方法来获取照片的正确旋转角度
//    // 根据设备旋转角度和相机传感器方向计算 JPEG_ORIENTATION
//    // 这部分逻辑比较复杂，需要查询 CameraCharacteristics.SENSOR_ORIENTATION
//    // 并考虑设备自然方向
//    // private int getOrientation(int rotation) {
//    //     // 示例：简单地根据设备旋转角度计算，实际可能需要更精确
//    //     // int sensorOrientation = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
//    //     // return (rotation + sensorOrientation + 270) % 360;
//    //     return 0; // 占位符
//    // }
//}